package com.woniuxy.vuecli.interceptor;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.woniuxy.vuecli.entity.ResponseResult;
import com.woniuxy.vuecli.util.JwtUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @Author author
 * @Create 2024-01-19 14:45
 */
@Slf4j
@Component
public class LoginInterceptor implements HandlerInterceptor {

    @Autowired
    RedisTemplate<String, Object> redisTemplate;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        log.info("进入LoginInterceptor：");
        if (request.getMethod().equals("OPTIONS")) {
            log.info("OPTIONS预检请求，直接放行");
            return true;
        }
        String token = request.getHeader("token");
        if (!StringUtils.isEmpty(token) && JwtUtil.verify(token)) {
            log.info("token有效，直接放行");
            return true;
        } else {
            log.info("token无效，拦截");
            ResponseResult<String> responseResult = new ResponseResult<>(401, "先登录", null);
            response.setContentType("text/html;charset=utf-8");
            response.getWriter().write(new ObjectMapper().writeValueAsString(responseResult));
            return false;
        }
    }
//    @Override
//    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//        log.info("进入LoginInterceptor：");
//
//        //跨域，有些格式的请求，发送正式请求(get,post,delete,put)之前，发送一个预检请求(OPTIONS)
//        if(request.getMethod().equals("OPTIONS")){
//            log.info("OPTIONS预检请求，直接放行");
//            return true;
//        }
//
//        //前端将token通过请求头，发送给后端；后端获取请求头的token，延展
//        String token = request.getHeader("token");
//        if(!StringUtils.isEmpty(token) && JwtUtil.verify(token)){
//            log.info("token有效，验证是否过期");
//            if(JwtUtil.isExpire(token)){
//                log.info("token有效，已经过期，Redis查询是否存在");
//                if(redisTemplate.hasKey("token:"+token)){
//                    log.info("token有效，已经过期，Redis没有过期，重新生成token,重新存入Reids，删除redis中原来的token");
//                    redisTemplate.delete("token:"+token);
//                    token = JwtUtil.create(JwtUtil.getEid(token), JwtUtil.getEname(token));
//                    redisTemplate.opsForValue().set("token:"+token, "xxxx", 20, TimeUnit.SECONDS);
//                    response.setHeader("token", token);
//                    response.setHeader("Access-Control-Expose-Headers", "*");
//                    return true;
//                }else{
//                    log.info("token有效，已经过期，Redis也过期，重新登录");
//                    ResponseResult<String> responseResult = new ResponseResult<>(401, "先登录", null);
//                    //@ResponseBody,将响应对象，自动序列化成JSON响应给前端。拦截器不能使用这个注解，自己序列化JSON
//                    //JSON工具类:jsonlib(老),fastjson（阿里）,gson(谷歌),jackson(SpringMVC默认使用)
//                    response.setContentType("text/html;charset=utf-8");
//                    response.getWriter().write(new ObjectMapper().writeValueAsString(responseResult));
//                    return false;
//                }
//            }else{
//                log.info("token有效，没有过期,直接放行");
//                return true;
//            }
//        }else{
//            log.info("token无效，拦截");
//            //请求被拦截，使用统一响应体发送给前端
//            ResponseResult<String> responseResult = new ResponseResult<>(401, "先登录", null);
//            //@ResponseBody,将响应对象，自动序列化成JSON响应给前端。拦截器不能使用这个注解，自己序列化JSON
//            //JSON工具类:jsonlib(老),fastjson（阿里）,gson(谷歌),jackson(SpringMVC默认使用)
//            response.setContentType("text/html;charset=utf-8");
//            response.getWriter().write(new ObjectMapper().writeValueAsString(responseResult));
//            return false;
//        }
//    }


//    @Override
//    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//        log.info("进入LoginInterceptor：");
//
//        //跨域，有些格式的请求，发送正式请求(get,post,delete,put)之前，发送一个预检请求(OPTIONS)
//        if(request.getMethod().equals("OPTIONS")){
//            log.info("OPTIONS预检请求，直接放行");
//            return true;
//        }
//
//        //前端将token通过请求头，发送给后端；后端获取请求头的token，延展
//        String token = request.getHeader("token");
//        if(!StringUtils.isEmpty(token) && JwtUtil.verify(token)){
//            log.info("token有效，验证是否过期");
//            if(JwtUtil.isExpire(token)){
//                log.info("token有效，已经过期,校验refreshtoken");
//                String refreshtoken=request.getHeader("refreshtoken");
//                if( !StringUtils.isEmpty(refreshtoken) && !JwtUtil.isExpire(refreshtoken) ){
//                    log.info("refreshtoken有效，没有过期,重新生成双token,放行");
//                    token=JwtUtil.create(JwtUtil.getEid(token),JwtUtil.getEname(token));
//                    refreshtoken=JwtUtil.createfresh(JwtUtil.getEid(token),JwtUtil.getEname(token));
//                    response.setHeader("token", token);
//                    response.setHeader("refreshtoken", refreshtoken);
//                    response.setHeader("Access-Control-Expose-Headers", "*");
//                    return true;
//                }else{
//                    log.info("refreshtoken，已经过期,拦截，重新登录");
//                    ResponseResult<String> responseResult = new ResponseResult<>(401, "双token失效，重新登录", null);
//                    //@ResponseBody,将响应对象，自动序列化成JSON响应给前端。拦截器不能使用这个注解，自己序列化JSON
//                    //JSON工具类:jsonlib(老),fastjson（阿里）,gson(谷歌),jackson(SpringMVC默认使用)
//                    response.setContentType("text/html;charset=utf-8");
//                    response.getWriter().write(new ObjectMapper().writeValueAsString(responseResult));
//                    return false;
//                }
//            }else{
//                log.info("token有效，没有过期,直接放行");
//                return true;
//            }
//        }else{
//            log.info("token无效，拦截");
//            //请求被拦截，使用统一响应体发送给前端
//            ResponseResult<String> responseResult = new ResponseResult<>(401, "先登录", null);
//            //@ResponseBody,将响应对象，自动序列化成JSON响应给前端。拦截器不能使用这个注解，自己序列化JSON
//            //JSON工具类:jsonlib(老),fastjson（阿里）,gson(谷歌),jackson(SpringMVC默认使用)
//            response.setContentType("text/html;charset=utf-8");
//            response.getWriter().write(new ObjectMapper().writeValueAsString(responseResult));
//            return false;
//        }
//    }


//    @Override
//    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//        log.info("进入LoginInterceptor：");
//
//        //跨域，有些格式的请求，发送正式请求(get,post,delete,put)之前，发送一个预检请求(OPTIONS)
//        if(request.getMethod().equals("OPTIONS")){
//            log.info("OPTIONS预检请求，直接放行");
//            return true;
//        }
//
//        //前端将token通过请求头，发送给后端；后端获取请求头的token，延展
//        String token = request.getHeader("token");
//        if(!StringUtils.isEmpty(token) && JwtUtil.verify(token)){
//            log.info("token有效，验证是否过期");
//            if(JwtUtil.isExpire(token)){
//                log.info("token有效，过期，拦截");
//                ResponseResult<String> responseResult = new ResponseResult<>(401, "token过期重新登录", null);
//                //@ResponseBody,将响应对象，自动序列化成JSON响应给前端。拦截器不能使用这个注解，自己序列化JSON
//                //JSON工具类:jsonlib(老),fastjson（阿里）,gson(谷歌),jackson(SpringMVC默认使用)
//                response.setContentType("text/html;charset=utf-8");
//                response.getWriter().write(new ObjectMapper().writeValueAsString(responseResult));
//                return false;
//            }else{
//                log.info("token有效，没有过期，放行，每次都续期");
//                //续期：生成一个新的token响应给用户
//                String newtoken = JwtUtil.create(JwtUtil.getEid(token), JwtUtil.getEname(token));
//                //token存入响应头
//                response.setHeader("token", newtoken);
//                //前后端分离，跨域，后端必须暴露响应头，否则前端无法获取
//                response.setHeader("Access-Control-Expose-Headers", "token");
//                return true;
//            }
//        }else{
//            log.info("token无效，拦截");
//            //请求被拦截，使用统一响应体发送给前端
//            ResponseResult<String> responseResult = new ResponseResult<>(401, "先登录", null);
//            //@ResponseBody,将响应对象，自动序列化成JSON响应给前端。拦截器不能使用这个注解，自己序列化JSON
//            //JSON工具类:jsonlib(老),fastjson（阿里）,gson(谷歌),jackson(SpringMVC默认使用)
//            response.setContentType("text/html;charset=utf-8");
//            response.getWriter().write(new ObjectMapper().writeValueAsString(responseResult));
//            return false;
//        }
//    }
}
